#include "gtkbindingsprivate.h"
#include "gtkintl.h"
+#include "gtkshortcuttrigger.h"
#include "gtkwidget.h"
/**
{
GObject parent_instance;
- GdkModifierType mods;
- guint keyval;
-
+ GtkShortcutTrigger *trigger;
char *signal;
GVariant *args;
};
PROP_0,
PROP_ARGUMENTS,
PROP_SIGNAL,
+ PROP_TRIGGER,
N_PROPS
};
{
GtkShortcut *self = GTK_SHORTCUT (object);
+ g_clear_pointer (&self->trigger, gtk_shortcut_trigger_unref);
g_clear_pointer (&self->signal, g_free);
g_clear_pointer (&self->args, g_variant_unref);
g_value_set_string (value, self->signal);
break;
+ case PROP_TRIGGER:
+ g_value_set_boxed (value, self->trigger);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
gtk_shortcut_set_signal (self, g_value_get_string (value));
break;
+ case PROP_TRIGGER:
+ gtk_shortcut_set_trigger (self, g_value_dup_boxed (value));
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
NULL,
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+ /**
+ * GtkShortcut:trigger:
+ *
+ * The trigger that triggers this shortcut.
+ */
+ properties[PROP_TRIGGER] =
+ g_param_spec_boxed ("trigger",
+ P_("Trigger"),
+ P_("The trigger for this shortcut"),
+ GTK_TYPE_SHORTCUT_TRIGGER,
+ G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
+
g_object_class_install_properties (gobject_class, N_PROPS, properties);
}
static void
gtk_shortcut_init (GtkShortcut *self)
{
+ self->trigger = gtk_shortcut_trigger_ref (gtk_never_trigger_get ());
}
/**
return g_object_new (GTK_TYPE_SHORTCUT, NULL);
}
-void
-gtk_shortcut_set_keyval (GtkShortcut *self,
- guint keyval,
- GdkModifierType mods)
-{
- g_return_if_fail (GTK_IS_SHORTCUT (self));
-
- /* To deal with <Shift>, we need to uppercase
- * or lowercase depending on situation.
- */
- if (mods & GDK_SHIFT_MASK)
- {
- if (keyval == GDK_KEY_Tab)
- keyval = GDK_KEY_ISO_Left_Tab;
- else
- keyval = gdk_keyval_to_upper (keyval);
- }
- else
- {
- if (keyval == GDK_KEY_ISO_Left_Tab)
- keyval = GDK_KEY_Tab;
- else
- keyval = gdk_keyval_to_lower (keyval);
- }
-
- self->keyval = keyval;
- self->mods = mods;
-}
-
gboolean
gtk_shortcut_trigger (GtkShortcut *self,
GdkEvent *event)
{
- GdkModifierType mods;
- guint keyval;
-
- if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
- return FALSE;
-
- /* XXX: This needs to deal with groups */
- mods = gdk_event_get_modifier_state (event);
- keyval = gdk_key_event_get_keyval (event);
-
- return keyval == self->keyval && mods == self->mods;
+ return gtk_shortcut_trigger_trigger (self->trigger, event);
}
gboolean
&handled,
&error))
{
- char *accelerator = gtk_accelerator_name (self->keyval, self->mods);
+ char *accelerator = gtk_shortcut_trigger_to_string (self->trigger);
g_warning ("gtk_shortcut_activate(): \":%s\": %s",
accelerator,
error->message);
}
}
+/**
+ * gtk_shortcut_get_trigger:
+ * @self: a #GtkShortcut
+ *
+ * Gets the trigger used to trigger @self.
+ *
+ * Returns: (transfer none): the trigger used
+ **/
+GtkShortcutTrigger *
+gtk_shortcut_get_trigger (GtkShortcut *self)
+{
+ g_return_val_if_fail (GTK_IS_SHORTCUT (self), NULL);
+
+ return self->trigger;
+}
+
+/**
+ * gtk_shortcut_set_trigger:
+ * @self: a #GtkShortcut
+ * @trigger: (transfer full) (nullable): The new trigger.
+ * If the @trigger is %NULL, the never trigger will be used.
+ *
+ * Sets the new trigger for @self to be @trigger.
+ **/
+void
+gtk_shortcut_set_trigger (GtkShortcut *self,
+ GtkShortcutTrigger *trigger)
+{
+ g_return_if_fail (GTK_IS_SHORTCUT (self));
+
+ if (trigger == NULL)
+ trigger = gtk_shortcut_trigger_ref (gtk_never_trigger_get ());
+
+ if (self->trigger == trigger)
+ {
+ gtk_shortcut_trigger_unref (trigger);
+ return;
+ }
+
+ gtk_shortcut_trigger_unref (self->trigger);
+ self->trigger = trigger;
+
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TRIGGER]);
+}
+
GVariant *
gtk_shortcut_get_arguments (GtkShortcut *self)
{
--- /dev/null
+/*
+ * Copyright © 2018 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+/**
+ * SECTION:gtkshortcuttrigger
+ * @Title: GtkShortcutTrigger
+ * @Short_description: Triggers to track if shortcuts should be activated
+ * @See_also: #GtkShortcut
+ *
+ * #GtkShortcutTrigger is the object used to track if a #GtkShortcut should be
+ * activated. For this purpose, gtk_shortcut_trigger_trigger() can be called
+ * on a #GdkEvent.
+ *
+ * #GtkShortcutTriggers contain functions that allow easy presentation to end
+ * users as well as being printed for debugging.
+ *
+ * All #GtkShortcutTriggers are immutable, you can only specify their properties
+ * during construction. If you want to change a trigger, you have to replace it
+ * with a new one.
+ */
+
+#include "config.h"
+
+#include "gtkshortcuttrigger.h"
+
+#include "gtkaccelgroup.h"
+
+typedef struct _GtkShortcutTriggerClass GtkShortcutTriggerClass;
+
+#define GTK_IS_SHORTCUT_TRIGGER_TYPE(trigger,type) (GTK_IS_SHORTCUT_TRIGGER (trigger) && (trigger)->trigger_class->trigger_type == (type))
+
+struct _GtkShortcutTrigger
+{
+ const GtkShortcutTriggerClass *trigger_class;
+
+ gatomicrefcount ref_count;
+};
+
+struct _GtkShortcutTriggerClass
+{
+ GtkShortcutTriggerType trigger_type;
+ gsize struct_size;
+ const char *type_name;
+
+ void (* finalize) (GtkShortcutTrigger *trigger);
+ gboolean (* trigger) (GtkShortcutTrigger *trigger,
+ GdkEvent *event);
+ void (* print) (GtkShortcutTrigger *trigger,
+ GString *string);
+};
+
+static GtkShortcutTrigger * gtk_shortcut_trigger_new (const GtkShortcutTriggerClass *trigger_class,
+ gsize extra_size);
+
+
+G_DEFINE_BOXED_TYPE (GtkShortcutTrigger, gtk_shortcut_trigger,
+ gtk_shortcut_trigger_ref,
+ gtk_shortcut_trigger_unref)
+
+static void
+gtk_shortcut_trigger_finalize (GtkShortcutTrigger *self)
+{
+ self->trigger_class->finalize (self);
+
+ g_free (self);
+}
+
+/*< private >
+ * gtk_shortcut_trigger_new:
+ * @trigger_class: class structure for this trigger
+ *
+ * Returns: (transfer full): the newly created #GtkShortcutTrigger
+ */
+GtkShortcutTrigger *
+gtk_shortcut_trigger_new (const GtkShortcutTriggerClass *trigger_class,
+ gsize extra_size)
+{
+ GtkShortcutTrigger *self;
+
+ g_return_val_if_fail (trigger_class != NULL, NULL);
+
+ self = g_malloc0 (trigger_class->struct_size + extra_size);
+ g_atomic_ref_count_init (&self->ref_count);
+
+ self->trigger_class = trigger_class;
+
+ return self;
+}
+
+/**
+ * gtk_shortcut_trigger_ref:
+ * @self: a #GtkShortcutTrigger
+ *
+ * Acquires a reference on the given #GtkShortcutTrigger.
+ *
+ * Returns: (transfer full): the #GtkShortcutTrigger with
+ * an additional reference
+ */
+GtkShortcutTrigger *
+gtk_shortcut_trigger_ref (GtkShortcutTrigger *self)
+{
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), NULL);
+
+ g_atomic_ref_count_inc (&self->ref_count);
+
+ return self;
+}
+
+/**
+ * gtk_shortcut_trigger_unref:
+ * @self: (transfer full): a #GtkShortcutTrigger
+ *
+ * Releases a reference on the given #GtkShortcutTrigger.
+ *
+ * If the reference was the last, the resources associated
+ * to the trigger are freed.
+ */
+void
+gtk_shortcut_trigger_unref (GtkShortcutTrigger *self)
+{
+ g_return_if_fail (GTK_IS_SHORTCUT_TRIGGER (self));
+
+ if (g_atomic_ref_count_dec (&self->ref_count))
+ gtk_shortcut_trigger_finalize (self);
+}
+
+/**
+ * gtk_shortcut_trigger_get_trigger_type:
+ * @self: a #GtkShortcutTrigger
+ *
+ * Returns the type of the @trigger.
+ *
+ * Returns: the type of the #GtkShortcutTrigger
+ */
+GtkShortcutTriggerType
+gtk_shortcut_trigger_get_trigger_type (GtkShortcutTrigger *self)
+{
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), GTK_SHORTCUT_TRIGGER_NEVER);
+
+ return self->trigger_class->trigger_type;
+}
+
+/**
+ * gtk_shortcut_trigger_trigger:
+ * @self: a #GtkShortcutTrigger
+ * @event: the event to check
+ *
+ * Checks if the given @event triggers @self. If so,
+ * returns %TRUE.
+ *
+ * Returns: %TRUE if this event triggered the trigger
+ **/
+gboolean
+gtk_shortcut_trigger_trigger (GtkShortcutTrigger *self,
+ GdkEvent *event)
+{
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER (self), FALSE);
+
+ return self->trigger_class->trigger (self, event);
+}
+
+/**
+ * gtk_shortcut_trigger_to_string:
+ * @self: a #GtkShortcutTrigger
+ *
+ * Prints the given trigger into a human-readable string.
+ * This is a small wrapper around gdk_content_formats_print()
+ * to help when debugging.
+ *
+ * Returns: (transfer full): a new string
+ **/
+char *
+gtk_shortcut_trigger_to_string (GtkShortcutTrigger *self)
+{
+ GString *string;
+
+ g_return_val_if_fail (self != NULL, NULL);
+
+ string = g_string_new (NULL);
+ gtk_shortcut_trigger_print (self, string);
+
+ return g_string_free (string, FALSE);
+}
+
+/**
+ * gtk_shortcut_trigger_print:
+ * @self: a #GtkShortcutTrigger
+ * @string: a #GString to print into
+ *
+ * Prints the given trigger into a string for the developer.
+ * This is meant for debugging and logging.
+ *
+ * The form of the representation may change at any time
+ * and is not guaranteed to stay identical.
+ **/
+void
+gtk_shortcut_trigger_print (GtkShortcutTrigger *self,
+ GString *string)
+{
+ g_return_if_fail (GTK_IS_SHORTCUT_TRIGGER (self));
+ g_return_if_fail (string != NULL);
+
+ return self->trigger_class->print (self, string);
+}
+
+/*** GTK_SHORTCUT_TRIGGER_NEVER ***/
+
+typedef struct _GtkNeverTrigger GtkNeverTrigger;
+
+struct _GtkNeverTrigger
+{
+ GtkShortcutTrigger trigger;
+
+ guint never;
+ GdkModifierType modifiers;
+};
+
+static void
+gsk_never_trigger_finalize (GtkShortcutTrigger *trigger)
+{
+ g_assert_not_reached ();
+}
+
+static gboolean
+gsk_never_trigger_trigger (GtkShortcutTrigger *trigger,
+ GdkEvent *event)
+{
+ return FALSE;
+}
+
+static void
+gsk_never_trigger_print (GtkShortcutTrigger *trigger,
+ GString *string)
+{
+ g_string_append (string, "<never>");
+}
+
+static const GtkShortcutTriggerClass GTK_NEVER_TRIGGER_CLASS = {
+ GTK_SHORTCUT_TRIGGER_NEVER,
+ sizeof (GtkNeverTrigger),
+ "GtkNeverTrigger",
+ gsk_never_trigger_finalize,
+ gsk_never_trigger_trigger,
+ gsk_never_trigger_print
+};
+
+static GtkNeverTrigger never = { { >K_NEVER_TRIGGER_CLASS, 1 } };
+
+/**
+ * gsk_never_trigger_get:
+ *
+ * Gets the never trigger. This is a singleton for a trigger
+ * that never triggers. Use this trigger instead of %NULL
+ * because it implements all virtual functions.
+ *
+ * Returns: (transfer none): The never trigger
+ */
+GtkShortcutTrigger *
+gtk_never_trigger_get (void)
+{
+ return &never.trigger;
+}
+
+/*** GTK_KEYVAL_TRIGGER ***/
+
+typedef struct _GtkKeyvalTrigger GtkKeyvalTrigger;
+
+struct _GtkKeyvalTrigger
+{
+ GtkShortcutTrigger trigger;
+
+ guint keyval;
+ GdkModifierType modifiers;
+};
+
+static void
+gsk_keyval_trigger_finalize (GtkShortcutTrigger *trigger)
+{
+}
+
+static gboolean
+gsk_keyval_trigger_trigger (GtkShortcutTrigger *trigger,
+ GdkEvent *event)
+{
+ GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
+ GdkModifierType modifiers;
+ guint keyval;
+
+ if (gdk_event_get_event_type (event) != GDK_KEY_PRESS)
+ return FALSE;
+
+ /* XXX: This needs to deal with groups */
+ modifiers = gdk_event_get_modifier_state (event);
+ keyval = gdk_key_event_get_keyval (event);
+
+ if (keyval == GDK_KEY_ISO_Left_Tab)
+ keyval = GDK_KEY_Tab;
+ else
+ keyval = gdk_keyval_to_lower (keyval);
+
+ return keyval == self->keyval && modifiers == self->modifiers;
+}
+
+static void
+gsk_keyval_trigger_print (GtkShortcutTrigger *trigger,
+ GString *string)
+{
+ GtkKeyvalTrigger *self = (GtkKeyvalTrigger *) trigger;
+ char *accelerator_name;
+
+ accelerator_name = gtk_accelerator_name (self->keyval, self->modifiers);
+ g_string_append (string, accelerator_name);
+ g_free (accelerator_name);
+}
+
+static const GtkShortcutTriggerClass GTK_KEYVAL_TRIGGER_CLASS = {
+ GTK_SHORTCUT_TRIGGER_KEYVAL,
+ sizeof (GtkKeyvalTrigger),
+ "GtkKeyvalTrigger",
+ gsk_keyval_trigger_finalize,
+ gsk_keyval_trigger_trigger,
+ gsk_keyval_trigger_print
+};
+
+/**
+ * gsk_keyval_trigger_new:
+ * @keyval: The keyval to trigger for
+ * @modifiers: the modifiers that need to be present
+ *
+ * Creates a #GtkShortcutTrigger that will trigger whenever
+ * the key with the given @keyval and @modifiers is pressed.
+ *
+ * Returns: A new #GtkShortcutTrigger
+ */
+GtkShortcutTrigger *
+gtk_keyval_trigger_new (guint keyval,
+ GdkModifierType modifiers)
+{
+ GtkKeyvalTrigger *self;
+
+ self = (GtkKeyvalTrigger *) gtk_shortcut_trigger_new (>K_KEYVAL_TRIGGER_CLASS, 0);
+
+ /* We store keyvals as lower key */
+ if (keyval == GDK_KEY_ISO_Left_Tab)
+ self->keyval = GDK_KEY_Tab;
+ else
+ self->keyval = gdk_keyval_to_lower (keyval);
+ self->modifiers = modifiers;
+
+ return &self->trigger;
+}
+
+/**
+ * gtk_keyval_trigger_get_modifiers:
+ * @self: a keyval #GtkShortcutTrigger
+ *
+ * Gets the modifiers that must be present to succeed
+ * triggering @self.
+ *
+ * Returns: the modifiers
+ **/
+GdkModifierType
+gtk_keyval_trigger_get_modifiers (GtkShortcutTrigger *self)
+{
+ GtkKeyvalTrigger *trigger = (GtkKeyvalTrigger *) self;
+
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_KEYVAL), 0);
+
+ return trigger->modifiers;
+}
+
+/**
+ * gtk_keyval_trigger_get_keyval:
+ * @self: a keyval #GtkShortcutTrigger
+ *
+ * Gets the keyval that must be pressed to succeed
+ * triggering @self.
+ *
+ * Returns: the keyval
+ **/
+guint
+gtk_keyval_trigger_get_keyval (GtkShortcutTrigger *self)
+{
+ GtkKeyvalTrigger *trigger = (GtkKeyvalTrigger *) self;
+
+ g_return_val_if_fail (GTK_IS_SHORTCUT_TRIGGER_TYPE (self, GTK_SHORTCUT_TRIGGER_KEYVAL), 0);
+
+ return trigger->keyval;
+}
--- /dev/null
+/*
+ * Copyright © 2018 Benjamin Otte
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Benjamin Otte <otte@gnome.org>
+ */
+
+#ifndef __GTK_SHORTCUT_TRIGGER_H__
+#define __GTK_SHORTCUT_TRIGGER_H__
+
+#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gtk/gtk.h> can be included directly."
+#endif
+
+#include <gtk/gtktypes.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_SHORTCUT_TRIGGER (gtk_shortcut_trigger_get_type ())
+
+#define GTK_IS_SHORTCUT_TRIGGER(obj) ((obj) != NULL)
+
+/**
+ * GtkShortcutTriggerType:
+ * @GTK_SHORTCUT_TRIGGER_NEVER: Never ever trigger
+ * @GTK_SHORTCUT_TRIGGER_KEYVAL: Trigger if a key even with matching
+ * modifiers and keyval is received.
+ *
+ * The type of a trigger determines what the trigger triggers on.
+ **/
+typedef enum {
+ GTK_SHORTCUT_TRIGGER_NEVER,
+ GTK_SHORTCUT_TRIGGER_KEYVAL
+} GtkShortcutTriggerType;
+
+GDK_AVAILABLE_IN_ALL
+GType gtk_shortcut_trigger_get_type (void) G_GNUC_CONST;
+
+GDK_AVAILABLE_IN_ALL
+GtkShortcutTrigger * gtk_shortcut_trigger_ref (GtkShortcutTrigger *self);
+GDK_AVAILABLE_IN_ALL
+void gtk_shortcut_trigger_unref (GtkShortcutTrigger *self);
+
+GDK_AVAILABLE_IN_ALL
+GtkShortcutTriggerType gtk_shortcut_trigger_get_trigger_type (GtkShortcutTrigger *self);
+
+GDK_AVAILABLE_IN_ALL
+char * gtk_shortcut_trigger_to_string (GtkShortcutTrigger *self);
+GDK_AVAILABLE_IN_ALL
+void gtk_shortcut_trigger_print (GtkShortcutTrigger *self,
+ GString *string);
+
+GDK_AVAILABLE_IN_ALL
+gboolean gtk_shortcut_trigger_trigger (GtkShortcutTrigger *self,
+ GdkEvent *event);
+
+GDK_AVAILABLE_IN_ALL
+GtkShortcutTrigger * gtk_never_trigger_get (void);
+
+GDK_AVAILABLE_IN_ALL
+GtkShortcutTrigger * gtk_keyval_trigger_new (guint keyval,
+ GdkModifierType modifiers);
+GDK_AVAILABLE_IN_ALL
+GdkModifierType gtk_keyval_trigger_get_modifiers (GtkShortcutTrigger *self);
+GDK_AVAILABLE_IN_ALL
+guint gtk_keyval_trigger_get_keyval (GtkShortcutTrigger *self);
+
+G_END_DECLS
+
+#endif /* __GTK_SHORTCUT_TRIGGER_H__ */
projects / gtk4.git / commitdiff